Language-side Foreign Function Interfaces with NativeBoost

International audienceForeign-Function-Interfaces (FFIs) are a prerequisite for close system integration of a high-level language. With FFIs the high-level environment interacts with low-level functions allowing for a unique combination of features. This duality has a strong impact on the implementation of the FFI: it has to be flexible and fast at the same time. We propose NativeBoost a language-side approach to FFIs that only requires minimal changes to the VM. NativeBoost directly creates specific native code at language-side and thus combines the flexibility of a language-side library with the performance of a native plugin

Benzo: Reflective Glue for Low-level Programming

International audienceThe goal of high-level low-level programming is to bring the abstraction capabilities of high-level languages to the system programming domain, such as virtual machines (VMs) and language runtimes. However, existing solutions are bound to compilation time and expose limited possibilities to be changed at runtime and from language-side. They do not fit well with fully reflective languages and environments. We propose Benzo1, a lightweight framework for high- level low-level programming that allows developers to generate and execute at runtime low-level code (assembly). It promotes the implementation, and dynamic modification, of system components with high-level language tools outperforming existing dynamic solutions. Since Benzo is a general framework we choose three applications that cover an important range of the spectrum of system programming for validating the infrastructure: a For- eign Function Interface (FFI), primitives instrumentation and a just-in-time bytecode compiler (JIT). With Benzo we show that these typical VM-level components are feasible as reflective language-side implementations. Due to its unique combination of high-level reflection and low-level programming, Benzo shows better performance for these three applications than the comparable high-level implementations

Flexible Object Layouts: enabling lightweight language extensions by intercepting slot access

International audienceProgramming idioms, design patterns and application li- braries often introduce cumbersome and repetitive boiler- plate code to a software system. Language extensions and external DSLs (domain specific languages) are sometimes introduced to reduce the need for boilerplate code, but they also complicate the system by introducing the need for lan- guage dialects and inter-language mediation. To address this, we propose to extend the structural reflec- tive model of the language with object layouts, layout scopes and slots. Based on the new reflective language model we can 1) provide behavioral hooks to object layouts that are triggered when the fields of an object are accessed and 2) simplify the implementation of state-related language exten- sions such as stateful traits. By doing this we show how many idiomatic use cases that normally require boilerplate code can be more effectively supported. We present an implementation in Smalltalk, and illustrate its usage through a series of extended examples

Waterfall: Primitives Generation on the Fly

Modern languages are typically supported by managed runtimes (Virtual Machines). Since VMs have to deal with many concepts such as memory management, abstract execution model and scheduling, they tend to be very complex. Additionally, VMs have to meet strong performance requirements. This demand of performance is one of the main reasons why many VMs are built statically. Thus, design decisions are frozen at compile time preventing changes at runtime. One clear example is the impossibility to dynamically adapt or change primitives of the VM once it has been compiled. In this work we present a toolchain that allows for altering and configuring components such as primitives and plug-ins at runtime. The main contribution is Waterfall, a dynamic and reflective translator from Slang, a restricted subset of Smalltalk, to native code. Waterfall generates primitives on demand and executes them on the fly. We validate our approach by implementing dynamic primitive modification and runtime customization of VM plug-ins

Functional balance at rest of hemispheric homologs assessed via normalized compression distance

Introduction: The formation and functioning of neural networks hinge critically on the balance between structurally homologous areas in the hemispheres. This balance, reflecting their physiological relationship, is fundamental for learning processes. In our study, we explore this functional homology in the resting state, employing a complexity measure that accounts for the temporal patterns in neurodynamics. Methods: We used Normalized Compression Distance (NCD) to assess the similarity over time, neurodynamics, of the somatosensory areas associated with hand perception (S1). This assessment was conducted using magnetoencephalography (MEG) in conjunction with Functional Source Separation (FSS). Our primary hypothesis posited that neurodynamic similarity would be more pronounced within individual subjects than across different individuals. Additionally, we investigated whether this similarity is influenced by hemisphere or age at a population level. Results: Our findings validate the hypothesis, indicating that NCD is a robust tool for capturing balanced functional homology between hemispheric regions. Notably, we observed a higher degree of neurodynamic similarity in the population within the left hemisphere compared to the right. Also, we found that intra-subject functional homology displayed greater variability in older individuals than in younger ones. Discussion: Our approach could be instrumental in investigating chronic neurological conditions marked by imbalances in brain activity, such as depression, addiction, fatigue, and epilepsy. It holds potential for aiding in the development of new therapeutic strategies tailored to these complex conditions, though further research is needed to fully realize this potential

Helicobacter pylori Up-regulates Cyclooxygenase-2 mRNA Expression and Prostaglandin E2 Synthesis in MKN 28 Gastric Mucosal Cells in Vitro

Helicobacter pylori has been suggested to play a role in the development of gastric carcinoma in humans. Also, mounting evidence indicates that cyclooxygenase-2 overexpression is associated with gastrointestinal carcinogenesis. We studied the effect of H. pylori on the expression and activity of cyclooxygenase-1 and cyclooxygenase-2 in MKN 28 gastric mucosal cells. H. pylori did not affect cyclooxygenase-1 expression, whereas cyclooxygenase-2 mRNA levels increased by 5-fold at 24 h after incubation of MKN 28 cells with broth culture filtrates or bacterial suspensions from wild-type H. pylori strain. Also, H. pylori caused a 3-fold increase in the release of prostaglandin E2, the main product of cyclooxygenase activity. This effect was specifically related to H. pylori because it was not observed with Escherichia coli and was independent of VacA, CagA, or ammonia. H. pylori isogenic mutants specifically lacking picA or picB, which are responsible for cytokine production by gastric cells, were less effective in the up-regulation of cyclooxygenase-2 mRNA expression and in the stimulation of prostaglandin E2 release compared with the parental wild-type strain. This study suggests that development of gastric carcinoma associated with H. pylori infection may depend on the activation of cyclooxygenase-2-related events

Vers des machines virtuelles auto-décrites

High-level languages implement reflection which allows a language runtime to inspect and alter its own execution and state. These high-level languages typically run on top of virtual machines (vms) which have been built to create an abstraction layer over hardware. Due to the isolating nature of the vm, reflection is generally limited to the language-side. Several research vms overcome this separation and provide a unified model where there is no more a clear distinction between language-side and vm-side. In such a language runtime it is possible to reflectively modify vm components from language-side as they reside on the same abstraction layer.In this dissertation we follow the same global direction towards a unified language-runtime or self-aware vm. However, instead of looking for a holistic solution we focus on a minimal approach. Instead of using a custom tailored language runtime we use dynamic native code activation from language-side on top of an existing vm.We first present Benzo our framework for dynamic native code activation. Benzo provides a generic but low-level interface to the vm internals.Based on this framework we then evaluate several applications that typically require direct vm support. We show first how Benzo is used to build an efficient ffi interface, allowing for a more structured access to vm internal functions. To evaluate the limitations of Benzo we target two more applications: dynamic primitives and a language-side jit compiler. Both of them require a tight interaction with the underlying vm.Les langages de haut-niveau supportent des operations réflectives qui permettent à l’ environenment d’exécution d’un langage d’inspecter et de changer son propre état et sa propre exécution. Ces langages de haut-niveau s’exécutent normalement sur une machine virtuelle (vm) qui ajoute une couche d’abstraction au-dessus du matériel. À cause de cette séparation, peu d’opération réflectives sont disponibles pour inspecter et modifier la vm. Plusieurs vms expérimentales offrent de telles opérations réflectives en proposant un modèle unifié qui ne distingue pas la couche vm de la couche langage.Dans cette thèse, nous suivons une approche similaire qui propose un environnement d’exécution unifié et auto-décrit. Nous nous intéressons à une solution minimale. Au lieu de dépendre de modifications d’une vm, nous générons dynamiquement du code natif depuis la couche langage.Nous présentons Benzo, un framework pour la génération dynamique de code natif. Benzo fournit une interface générique et de bas-niveau pour accéder aux fonctionnalités fondamentales de la vm.Grâce à Benzo, nous analysons plusieurs applications qui nécessitent un accès direct à la vm. Nous montrons comment Benzo peut être utilisé pour implémenter une librairie de Foreign Function Interfaces, permettant de faciliter l’accès aux fonctionnalités bas-niveau de la vm. Pour évaluer les limitations de Benzo, nous visons deux autres applications: la génération dynamique de primitive et un compilateur jit (Just-In-Time). Ces deux applications doivent changer le comportement de la vm. Pour cela, elles ont besoin d’une interaction poussée avec la vm

PyGirl Generating Whole-System VMs from high-level models using PyPy

Virtual machines emulating hardware devices are generally implemented in low-level languages and using a low-level style for performance reasons. This trend results in largely difficult to understand, difficult to extend and unmaintainable systems. As new general techniques for virtual machines arise, it gets harder to incorporate or test these techniques because of early design and optimization decisions. In this paper we show how such decisions can be postponed to later phases by separating virtual machine implementation issues from the high-level machine-specific model. We construct compact models of whole-system VMs in a high-level language, which exclude all low-level implementation details. We use the pluggable translation toolchain PyPy to translate those models to executables. During the translation process, the toolchain reintroduces the VM implementation and optimization details for specific target platforms. As a case study we implement an executable model of a hardware gaming device. We show that our approach to VM building increases understandability, maintainability and extendability while preserving performance